home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / ccs / ccs-11tl.lha / lbl / x11 / libscs / convertu3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-10  |  19.6 KB  |  726 lines
  1. /*    CONVERTU . C
  2. %
  3. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  4.  
  5. This software is copyright (C) by the Lawrence Berkeley Laboratory.
  6. Permission is granted to reproduce this software for non-commercial
  7. purposes provided that this notice is left intact.
  8.  
  9. It is acknowledged that the U.S. Government has rights to this software
  10. under Contract DE-AC03-765F00098 between the U.S.  Department of Energy
  11. and the University of California.
  12.  
  13. This software is provided as a professional and academic contribution
  14. for joint exchange. Thus, it is experimental, and is provided ``as is'',
  15. with no warranties of any kind whatsoever, no support, no promise of
  16. updates, or printed documentation. By using this software, you
  17. acknowledge that the Lawrence Berkeley Laboratory and Regents of the
  18. University of California shall have no liability with respect to the
  19. infringement of other copyrights by any part of this software.
  20.  
  21. For further information about this notice, contact William Johnston,
  22. Bld. 50B, Rm. 2239, Lawrence Berkeley Laboratory, Berkeley, CA, 94720.
  23. (wejohnston@lbl.gov)
  24.  
  25. For further information about this software, contact:
  26.         Jin Guojun
  27.         Bld. 50B, Rm. 2275, Lawrence Berkeley Laboratory, Berkeley, CA, 94720.
  28.         g_jin@lbl.gov
  29.  
  30. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  31. %
  32. %    Converting interface for new HIPS_2 or other types.
  33. %    Make image filters have flexibility to handle different types.
  34. %    Usually, the HIPS is checked first, and then other types.
  35. %
  36. %    For color image input, the pxl_in always = 1.
  37. %
  38. %    The libscs1 requests FITS_IMAGE directives for handling HIPS and FITS
  39. %    images. The libscs2 requests another directive, RLE_IMAGE, to handle
  40. %    RLE image. The COMMON_TOOL directive requires to link with libtiff.a.
  41. %    Once COMMON_TOOL directive is defined, in general, this system will
  42. %    be able to handle following images:
  43. %
  44. %    HIPS, FITS, GIF, ICC, JPEG, PICT, PNM, RLE, SUN-RASTER, and TIFF
  45. %
  46. %    Color Map:
  47. %        input colormap (8-bit color) is in reg_cmap. get_pic() or
  48. %    other re-map reg_cmap to rle_dflt_hdr.cmap or other colormaps.
  49. %
  50. %    Channels:
  51. %        Input channel (img->channels) in returning of header_handler
  52. %    is the original channels. It can be changed in read_???_image()
  53. %    routine depended on img->mid_type and img->color_form. The output
  54. %    channel (img->dpy_channels) depends on output device and img->o_type.
  55. %
  56. % AUTHOR:    Jin Guojun - LBL    7/25/91
  57. */
  58.  
  59. #include "function.h"
  60.  
  61. char*    ITypeName[]={IName_List}, WHAT_Str[]="?";
  62.  
  63. #define    Real_STR(str)    (str ? str : WHAT_Str)
  64.  
  65. #include    "hdhandle.c"
  66.  
  67. #ifdef    FITS_IMAGE
  68.  
  69. FITS_BASE    fhd;
  70.  
  71. fits_header_handle(job, img, ac, av, assist)
  72. U_IMAGE    *img;
  73. int    ac;
  74. char    **av;
  75. VType    *assist;
  76. {
  77. switch(job) {
  78. case HEADER_READ:
  79. case HEADER_FREAD:
  80.     if (!av)    fseek(img->IN_FP, 0, 0);
  81.     if (feof(img->IN_FP))
  82.         return    EOF;    /* save no changes for other headers    */
  83.     if (!hostype)    {
  84.         hostype = check_host();
  85.         FTy = comfirm_host(img, hostype, FTy);
  86.     }
  87.     if (get_fits_head(&fhd, img, hostype, FTy))
  88.         return    EOF;
  89.     img->in_type = FITS;
  90.     img->in_color = img->color_form = CFM_SGF;
  91.     goto    fit_set;
  92. case HEADER_FROM:
  93.     img->frames = fhd.naxis3;
  94.     img->width = fhd.naxis2;
  95.     img->height = fhd.naxis1;
  96.     img->pxl_in = fhd.bits_pxl>>3;
  97.     img->in_form = img->pxl_in>>1;
  98.     img->history = fhd.history;
  99. fit_set:
  100.     img->dpy_channels = img->channels = img->mono_img = 1;
  101. #if    defined    COMMON_TOOL | defined RLE_IMAGE
  102.     if (img->mid_type==RLE)
  103.         rle_dflt_hdr.ncmap = 0;
  104. #endif
  105.     break;
  106. case HEADER_TO:
  107. case HEADER_WRITE:    /* to standard output */
  108. case HEADER_FWRITE:
  109.     if(img->o_type==FITS)    {
  110.         fhd.naxis3 = img->frames;
  111.         fhd.naxis1 = img->height;
  112.         fhd.naxis2 = img->width;
  113.         fhd.history = img->history;
  114.         fhd.bits_pxl = img->pxl_out<<3;
  115.         if (job==HEADER_TO)    break;
  116.         put_fits_head(&fhd, img, ac);
  117.     }
  118. #if defined    (COMMON_TOOL) | defined RLE_IMAGE
  119.     else    return    rle_header_handle(job, img, ac, av, assist);
  120. #endif
  121.     break;
  122. default:message("unknown job %d\n", job);
  123.     return    job;
  124. }
  125. return    0;
  126. }
  127. #endif    FITS_IMAGE
  128.  
  129.  
  130. #if    defined    COMMON_TOOL | defined    RLE_IMAGE
  131.  
  132. rle_header_handle(job, img, ac, av, assist)
  133. U_IMAGE    *img;
  134. int    ac;
  135. char    **av;
  136. VType    *assist;
  137. {
  138. register int    i;
  139.  
  140. switch (job) {
  141. case HEADER_READ:
  142. case HEADER_FREAD:    /* av indicates a multiple-frame image */
  143.     if (!av)
  144.         fseek(img->IN_FP, 0, 0);
  145.     rle_dflt_hdr.rle_file = img->IN_FP;
  146.     if ((i=rle_get_setup(&rle_dflt_hdr)) != RLE_SUCCESS)
  147.         return    i;
  148.     img->in_type = RLE;
  149. case HEADER_FROM:
  150.     img->mag_h = img->height =
  151.         rle_dflt_hdr.ymax - (img->y0 = rle_dflt_hdr.ymin) + 1;
  152.     img->mag_w = img->width =
  153.         rle_dflt_hdr.xmax - (img->x0 = rle_dflt_hdr.xmin) + 1;
  154.     /*    for rle_getrow    */
  155.     rle_dflt_hdr.xmin = 0;    rle_dflt_hdr.xmax = img->width - 1;
  156.     img->pxl_in = 1;
  157.  
  158.     img->in_color = rle_dflt_hdr.ncolors;
  159.     /* kludge do it, dangerous when change CFM & IFMT definions */
  160.     if (img->in_color == 3)
  161.         img->in_color = CFM_ILL,
  162.         img->in_form = IFMT_ILL;
  163.     else if (img->in_color &= rle_dflt_hdr.ncmap)
  164.         img->in_form = IFMT_SCF;
  165.     else    img->in_form = IFMT_SGF;
  166.     img->color_form = img->in_color;
  167.  
  168.     if (rle_dflt_hdr.comments && rle_dflt_hdr.comments[0])
  169.         img->desc = (char*)str_save(rle_dflt_hdr.comments[0]);
  170.     /*    We are only interested in R.G.B.    */
  171.     for (i=3; i < rle_dflt_hdr.ncolors; i++)
  172.         RLE_CLR_BIT(rle_dflt_hdr, i);
  173.     RLE_CLR_BIT(rle_dflt_hdr, RLE_ALPHA);    /* rle.h L112 */
  174.     img->channels = rle_dflt_hdr.ncolors & 3;
  175.     img->cmaplen = 1 << rle_dflt_hdr.cmaplen;
  176.     img->dpy_channels &= img->channels;
  177.     break;
  178. case HEADER_TO:
  179. case HEADER_WRITE:    /* to standard output */
  180. case HEADER_FWRITE:
  181.     if (img->o_type != RLE)    return
  182. #    ifdef    COMMON_TOOL
  183.         icc_header_handle(job, img, ac, av, assist);
  184. #    else
  185.         EOF;
  186. #    endif
  187.     rle_dflt_hdr.xmin = rle_dflt_hdr.ymin = 0;
  188.     rle_dflt_hdr.ymax = img->height - 1;
  189.     rle_dflt_hdr.xmax = img->width - 1;
  190.     rle_dflt_hdr.ncolors = img->channels;
  191.     if (rle_dflt_hdr.comments)
  192.         rle_dflt_hdr.comments[0] = img->desc;
  193.     if (job==HEADER_TO)    break;
  194.     rle_put_setup(&rle_dflt_hdr);
  195.     break;
  196. default:message("unknown job %d\n", job);
  197.     return    job;
  198. }
  199. return    0;
  200. }
  201.  
  202. #endif    RLE_IMAGE
  203.  
  204.  
  205. /*=======================================================================
  206. %    For writing 3D sub-image, use HEADER_TO to set sub-image size,    %
  207. %    then use HEADER_WRITE with img->update_header==0 to output    %
  208. %    the pre-set header. Otherwise, the HEADER_WRITE only output a    %
  209. %    sub-image of an image having a single frame.            %
  210. %    Unsuccessful reading returns (-1) EOF, otherwise returns 0 and    %
  211. %    img->in_type is set to proper input image type such as HIPS.    %
  212. =======================================================================*/
  213. #ifdef  HIPS_IMAGE
  214.  
  215. struct    header    hhd;    /*    basic structure    */
  216.  
  217. hips_header_handle(job, img, ac, av, assist)
  218. U_IMAGE    *img;
  219. int    ac;
  220. char    **av;
  221. VType    *assist;
  222. {
  223. FILE    *o_fp=img->OUT_FP, *i_fp=img->IN_FP;
  224. int    hform;
  225.  
  226. switch (job) {
  227. case HEADER_FREAD:
  228.     i_fp = (FILE*)ac;
  229. case HEADER_READ:
  230. #ifdef    STREAM_IMAGE
  231.     set_jpeg_uimg(img);
  232. #endif
  233.     if (img->in_type != HIPS || H_fread_header(i_fp, &hhd))
  234.         return    EOF;
  235. #ifdef    STREAM_IMAGE
  236.     get_jpeg_uimg(img);
  237. #endif
  238.     goto    set_img;
  239. case HEADER_FROM:
  240.     if (ac)    memcpy(&hhd, ac, sizeof(hhd));
  241. set_img:
  242.     hform = hhd.pixel_format;
  243.     ac = ac=='p' && hform !=IFMT_ILC;/* treate RGB frame as G.S. frames */
  244.     img->in_type = HIPS;
  245.     img->cmaplen = 0;
  246.     img->color_form = CFM_SGF;    /* default to gray scale    */
  247.     img->channels = hhd.numcolor;
  248.     if (findparam(&hhd, "cmap") != NULLPAR)    {
  249.     VType*    cmapp;
  250.     int    nc;
  251.         getparam(&hhd, "cmap", PFBYTE, &nc, &cmapp);
  252.         if (nc % 3 || nc > MaxColors*3)
  253.             prgmerr(0, "strange colormap = %d", nc);
  254.         else    {
  255.             if (reg_cmap[0])
  256.                 free(reg_cmap[0]);
  257.             reg_cmap[0] = cmapp;
  258.             img->cmaplen = (nc /= 3);
  259.             reg_cmap[1] = reg_cmap[0] + nc;
  260.             reg_cmap[2] = reg_cmap[1] + nc;
  261.             img->in_color = img->color_form = CFM_SCF;
  262.         }
  263.     }
  264.     else    if (img->channels==3)    {    /* kludge handle SEPLANE */
  265.             if (hform==IFMT_ILC)    /* PFRGB */
  266.                 img->in_color = CFM_ILC;
  267. #    ifdef    STREAM_IMAGE
  268.             else if (img->in_form==IFMT_STREAM)
  269.                 img->color_form = CFM_ILL;
  270. #    endif
  271.             else    img->in_color = CFM_SEPLANE;
  272.         }
  273.         else if (hform==IFMT_ALPHA)
  274.             img->in_color = CFM_ALPHA,
  275.             img->channels = 4;
  276.         else if (hform == IFMT_ILC)
  277.             img->in_color = CFM_ILC,
  278.             img->channels = 3;
  279.         else    img->in_color = CFM_SGF;
  280.  
  281.     /*    should select_color_form here    */
  282.     if ((img->in_color == CFM_SEPLANE) & (ac | !img->color_dpy)) {
  283.         img->dpy_channels = 1;
  284.         if (!ac)    img->color_form = CFM_SGF;
  285.     }
  286.  
  287. #if    defined COMMON_TOOL | defined RLE_IMAGE
  288.     /* not force to stick at 1 channel    */
  289.     if (img->mid_type==RLE && img->cmaplen && !assist)    {
  290.         rle_dflt_hdr.ncmap = img->mono_img = 0;
  291.         if (img->color_form != CFM_SGF)
  292.             img->dpy_channels = img->channels = 3;
  293.     }
  294. #endif
  295.     img->frames = hhd.num_frame / hhd.numcolor;
  296.     img->in_form = hhd.pixel_format;
  297.     img->width = hhd.ocols;
  298.     img->height = hhd.orows;
  299.     img->pxl_in = pxl_size(hhd);
  300.     if (img->pxl_in == 3)
  301.         img->pxl_in = 1;    /* for PFRGB    */
  302.     if (!img->pxl_in) {
  303.     register int    vsize;
  304.         switch (img->in_form)    {
  305.         case IFMT_VFFT3D:
  306.         case IFMT_VFFT2D:
  307.         case IFMT_VVFFT3D:
  308.             vsize = sizeof(float)<<1;
  309.             break;
  310.         case IFMT_DVFFT3D:
  311.         case IFMT_DVFFT2D:
  312.         case IFMT_DVVFFT3D:
  313.             vsize = sizeof(double)<<1;
  314.             break;
  315.         case IFMT_HIST:
  316.             vsize  = sizeof(int);
  317.             break;
  318.         default:vsize = 1;
  319.             msg("%d: undetermined size", img->in_form);
  320.         }
  321.         img->pxl_in = vsize;
  322.     }
  323.     img->history = hhd.seq_history;
  324.     img->desc = hhd.seq_desc;
  325.     img->sub_img_w = hhd.cols;
  326.     img->sub_img_h = hhd.rows;
  327.     img->sub_img_x = hhd.fcol;
  328.     img->sub_img_y = hhd.frow;
  329.     get_superimpose_param(img, &hhd);
  330. #ifdef    STREAM_IMAGE
  331.     set_jpeg_uimg(img);
  332. #endif
  333.     break;
  334. case HEADER_TO:
  335.     if (img->o_type != HIPS)
  336. hhd_other:    return
  337. #ifdef    FITS_IMAGE
  338.         fits_header_handle(job, img, ac, av, assist);
  339. #else
  340.         EOF;
  341. #endif
  342.     if (img->o_type != img->in_type || ac    /* as initial_header_flag */)
  343.         (*img->std_swif)(FI_INIT_NAME, img, img->name, 0);
  344.     hhd.numcolor = img->dpy_channels;
  345.     hhd.num_frame = img->frames * hhd.numcolor;
  346.     if (hhd.numcolor == 3 && img->color_form == CFM_ILC)
  347.         hhd.pixel_format = IFMT_ILC;
  348.     else {    hhd.pixel_format = img->o_form;
  349.         if (img->color_form == CFM_SEPLANE)
  350.             hhd.numcolor = 3,    /* kludge handle SEPLANE. */
  351.             hhd.pixel_format = IFMT_BYTE;
  352.     }
  353.     hhd.fcol = hhd.frow = 0;
  354. /*
  355.     hhd.fcol = img->sub_img_x;    hhd.frow = img->sub_img_y;
  356. */
  357.     if (img->sub_img){
  358.         if (img->sub_img_w && img->sub_img_h) {
  359.         hhd.cols = img->sub_img_w;    /* if ROI then set ROI */
  360.         hhd.rows = img->sub_img_h;
  361.         }
  362.         hhd.ocols = img->sub_img_w;
  363.         hhd.orows = img->sub_img_h;
  364.     } else    {
  365.         hhd.ocols = hhd.cols = img->width;
  366.         hhd.orows = hhd.rows = img->height;
  367.     }
  368.  
  369.     if (img->desc)
  370.         hhd.seq_desc = img->desc;
  371.     else if (!hhd.seq_desc)
  372.         hhd.seq_desc = WHAT_Str;
  373.     if (img->dest && !hhd.image)
  374.         hhd.image = (byte *) img->dest;
  375.     set_pxl_size(hhd, img->pxl_out);
  376.     break;
  377. case HEADER_FWRITE:
  378.     o_fp = (FILE*)assist;    /* use given file pointer */
  379. case HEADER_WRITE:
  380.     if (img->o_type == HIPS) {
  381.         if (img->update_header) {
  382.         if (img->o_type != img->in_type)
  383.             (*img->std_swif)(FI_INIT_NAME, img, img->name, 0);
  384.         if ((hhd.numcolor=img->dpy_channels) == 3
  385.             && img->color_form == CFM_ILC)
  386.             hhd.pixel_format = IFMT_ILC;
  387.         else    hhd.pixel_format = img->o_form;
  388.         hhd.num_frame = img->frames * hhd.numcolor;
  389.         hhd.fcol = hhd.frow = 0;    /* not ROI for output    */
  390.         if (img->sub_img && img->frames==1) {
  391.             hhd.ocols = img->sub_img_w;
  392.             hhd.orows = img->sub_img_h;
  393.         } else    {
  394.             hhd.cols = hhd.ocols = img->width;
  395.             hhd.rows = hhd.orows = img->height;
  396.         }
  397.         set_pxl_size(hhd, img->pxl_out);
  398.         }
  399.         put_superimpose_param(img, &hhd);
  400.         if (img->cmaplen && img->color_dpy && img->color_form==CFM_SCF) {
  401. #ifdef    RLE_IMAGE
  402.         if (!reg_cmap[0])    /* must be in rlemap    */
  403.             rlemap_to_regmap(reg_cmap, &rle_dflt_hdr);
  404. #endif
  405.         setparam(&hhd, "cmap", IFMT_BYTE, 3*img->cmaplen, reg_cmap[0]);
  406.         }
  407.         if (assist)
  408.         H_update_header(&hhd, ac, av);
  409.         H_fwrite_header(o_fp, &hhd, img->name ? img->name:"std_in");
  410.     }
  411.     else    goto    hhd_other;
  412.     break;
  413. case ADD_DESC:
  414.     if (img->o_type != img->in_type)
  415.         (*img->std_swif)(FI_INIT_NAME, img, img->name, 0);
  416.     H_add_seq_desc(&hhd, ac);
  417.     img->desc = hhd.seq_desc;
  418.     break;
  419. default:message("unknown job %d\n", job);    return    job;
  420. }
  421. return    0;
  422. }
  423. #endif
  424.  
  425.  
  426. std_interface(needs, img, fmt, vva_list)
  427. U_IMAGE    *img;
  428. char    *fmt;
  429. VType    *vva_list;    /* actually, it should be < ... > in Turbo C. */
  430. {
  431. int    i=img->in_color, icf=img->color_form,
  432.     status=0, fsize=img->width*img->height,
  433.     frames=(needs==FI_SAVE_FILE) ? (img->save_all ? img->save_all : 1) *
  434.             img->pxl_out : (img->load_all ? img->load_all : 1) *
  435.             img->pxl_in * img->channels;
  436. char    *pany = img->src;
  437.  
  438. switch(needs) {
  439. case FI_LOAD_FILE:    /* vva_list is multi_hd (RLE) or OsameI8 */
  440.     switch (img->in_type)    {
  441. #ifdef    FITS_IMAGE
  442.     case FITS:
  443.         status = fsize - read_fits_image(img, FTy, DCMP, No, No);
  444.         break;
  445. #endif
  446. #ifdef  HIPS_IMAGE
  447.     case HIPS:
  448.         verify_buffer_size(&img->src, frames, fsize, "hips-src");
  449.         pany = img->src;
  450.     rdHIPS:
  451. #ifdef    STREAM_IMAGE
  452.         if (get_sinfo(NULL, 0))    {    /* input is a stream    */
  453.             hhd.image = pany;
  454.             if (fread_image(img->IN_FP, &hhd, img->fn, "stream")>-1)
  455.                 status = fsize;
  456.             break;
  457.         }
  458. #endif
  459.         img->cnvt = img->src;
  460.         if (i == CFM_SEPLANE && icf != CFM_SEPLANE)    {
  461.             img->src = pany;
  462.             status = read_sepplane_image(img, 0, frames/img->channels);
  463.             img->src = img->cnvt;
  464.         }
  465.         else    status = fread(pany, frames, fsize, img->IN_FP);
  466.         frames /= img->channels;
  467.         if (i==CFM_SCF)    {
  468.             if (!img->color_dpy) {
  469.             map8_gray(img->src, pany, fsize, reg_cmap);
  470.             img->color_form = CFM_SGF;
  471.             }
  472. #if    defined    COMMON_TOOL | defined RLE_IMAGE
  473.             else if (!vva_list && img->mid_type == RLE)    {
  474.             register char    *obp, *ibp;
  475.             register int    l;
  476.                 for (l=img->height; l--;)    {
  477.                 obp = (char*)img->src + img->width * 3 * l;
  478.                 ibp = (char*)img->src + img->width * l;
  479.                 ras8_to_rle(obp, ibp, img->width, img, reg_cmap, 1);
  480.                 }
  481.                 img->color_form = CFM_ILL; /* change color form */
  482.             }
  483.         }
  484.         else if (i==CFM_ILC || i==CFM_ALPHA) {
  485.             if (icf == CFM_ILL)    {
  486.             img->src = pany;
  487.             pany = nzalloc(img->channels, img->width, "db");
  488.             for (frames=img->width*img->channels, i=img->height; i--;) {
  489.             register byte*    p = ORIG_RLE_ROW(img, i);
  490.                 memcpy(pany, p, frames);
  491.                 any_ilc_to_rle(p, pany, img, img->channels, 0);
  492.             }
  493.             free(pany);    img->src = img->cnvt;
  494.             }
  495. #endif
  496.             else if (icf==CFM_SGF)
  497.             ilc_to_gray(img->src, pany + 1, fsize * frames,
  498.                 img->in_color==CFM_ALPHA, NULL, 0);
  499.         }
  500.         break;
  501. #endif
  502. #if    defined    COMMON_TOOL | defined    RLE_IMAGE
  503.     case RLE:
  504.         if ((frames /= img->channels) > 1)
  505.             verify_buffer_size(&img->src, frames, fsize, "multi-rle"),
  506.             pany = img->src;
  507.         else    pany = NULL;
  508.         while (1)    {
  509.             status = read_rle_image(img, reg_cmap, 0);
  510.             if (!--frames ||
  511.                 rle_get_setup(&rle_dflt_hdr) != RLE_SUCCESS)
  512.             break;
  513.             if (rle_dflt_hdr.xmax - rle_dflt_hdr.xmin + 1
  514.                 != img->width || img->height !=
  515.                 rle_dflt_hdr.ymax - rle_dflt_hdr.ymin + 1)
  516.             break;
  517.             img->src = (char*)img->src + fsize;
  518.         }
  519.         if (pany)    img->src = pany;
  520.         break;
  521. #endif
  522. #ifdef    COMMON_TOOL
  523.     case GIF:    status = read_gif_image(img, &GifScreen, 1);
  524.         break;
  525.     case ICC:    status = read_sepplane_image(img,
  526.                 icchd.img_hd.x_size - img->width, 1);
  527.         break;
  528.     case PBM:
  529.     case PPM:
  530.     case PNM:
  531.         status = read_pnm_image(img, maxval, format, xel24, cht, reg_cmap);
  532.         if (xel24 && !vva_list)
  533.             free_2d_discrete(xel24, img->height);
  534.         break;
  535.     case PGM:    status = read_pgm_image(img, maxval, format);
  536.         break;
  537.     case RAS:    status = read_rast_image(img, &srhd, vva_list);
  538.         break;
  539.     case TiFF:
  540.         status = read_tiff_image(img, reg_cmap, TIFFin, TiffRGB, vva_list);
  541.         break;
  542. #    ifdef    JPEG_IMAGE
  543.     case JPEG:    status = read_jpeg_image(img, vva_list, 0);
  544.         break;
  545. #    endif
  546. #    ifdef    PICT_IMAGE
  547.     case PICT:    status = read_pict_image(img, vva_list);
  548.         break;
  549. #    endif
  550. #endif
  551.     default:
  552.     status = prgmerr(0, "unable to process this type %d\n", img->in_type);
  553.     }
  554.     if (status < 0 || status != fsize)
  555.         prgmerr(fmt, "%s: load %s[%d] %d\n",
  556.             fmt, ITypeName[img->in_type], fsize, status);
  557.     if (icf==CFM_SEPLANE && icf != i)
  558.         any_to_seplane(img, img->dpy_channels, No, reg_cmap);
  559.     break;
  560.  
  561. #ifdef  HIPS_IMAGE
  562. case FI_ACCESS_ABS_FRAME:
  563.     switch (img->in_type) {
  564.     case HIPS:
  565.         i = (int) vva_list - img->fn;
  566.         img->fn = (int) vva_list;
  567.         fseek(img->IN_FP, i * fsize, SEEK_CUR);
  568.         goto    rlbHIPS;
  569.     default:    status = prgmerr(0, "only access HIPS");
  570.     }    break;
  571. #endif
  572. case FI_LOAD_ROW:    status = ccs_get_row(img, fmt, vva_list);
  573.     break;
  574. case FI_RLOAD_BUF:
  575.     switch (img->in_type) {
  576. #ifdef    FITS_IMAGE
  577.     case FITS: {
  578.         VType*    tp = img->src;
  579.         img->src = fmt;
  580.         status = read_fits_image(img, FTy, DCMP, No, No);
  581.         img->src = tp;
  582.     }    break;
  583. #endif
  584. #ifdef  HIPS_IMAGE
  585.     case HIPS:
  586. rlbHIPS:    pany = fmt;    fmt = 0;
  587.         goto    rdHIPS;    /*    buffer must be allocated    */
  588. #endif
  589. #ifdef    JPEG_IMAGE
  590.     case JPEG:
  591.         img->src = fmt;
  592.         status = read_jpeg_image(img, 0, 1);
  593.         img->src = pany;
  594.     break;
  595. #endif
  596.     default:status = EOF;
  597.     }
  598.     if (status != fsize)    prgmerr(0,"%s: load[%d] %d\n",
  599.             ITypeName[img->in_type], fsize, status);
  600.     break;
  601.  
  602. case FI_SAVE_FILE:
  603.     switch (img->o_type)    {
  604.     case FITS:
  605.         status = prgmerr(0, "not linked to fits write routine\n");
  606.         break;
  607. #ifdef  HIPS_IMAGE
  608.     case HIPS:    {    /* only color RLE to SGF    */
  609.     int    ch=img->dpy_channels, typediff=img->mid_type==RLE && ch > 1;
  610.     register int    w=img->width;
  611.     register char*    bp = pany = (fmt ? fmt : (char*)img->src) +
  612.                 (int)vva_list * fsize;
  613.  
  614.         if (img->sub_img) {
  615.             pany = bp += ch * img->sub_img_y * w + img->sub_img_x;
  616.             w = img->sub_img_w;
  617.             if (typediff)    {
  618.                 for (; ch--; bp = pany += img->width)
  619.                     for (i=img->sub_img_h; i--;)    {
  620.                     status += fwrite(bp, img->pxl_out, w,
  621.                         img->OUT_FP) - w;
  622.                     bp += img->width * ch;
  623.                     }
  624.             } else while (frames--)    {
  625.                 for (i=img->sub_img_h; i--; bp+=img->width)
  626.                     status += fwrite(bp, img->pxl_out, w,
  627.                     img->OUT_FP) - w;
  628.                 bp = pany += fsize;
  629.             }
  630.         }
  631.         else     {
  632.             if (typediff)    {
  633.             bp = nzalloc(ch*frames, fsize, "r-h");
  634.             line_to_sep_color(bp, pany, w, img->height*frames, ch);
  635.             }
  636.             status=(i=fwrite(bp, ch*frames, fsize, img->OUT_FP)) - fsize;
  637.             if (typediff)    free(bp);
  638.         }
  639.         if (img->update=status)
  640.             status = prgmerr(0, "%s[%d] update %d",
  641.                     ITypeName[img->o_type], fsize, i);
  642.     }    break;
  643. #endif
  644. #if    defined    COMMON_TOOL | defined RLE_IMAGE
  645.     case RLE:    write_rle(img, vva_list, fmt);    break;
  646. #endif
  647.  
  648. #if    defined    COMMON_TOOL & defined    WRITE_ANY_IMAGE
  649.     case RAS:    write_rast(img, vva_list, fmt);    break;
  650. #endif
  651.     default:
  652.         status = prgmerr(0, "unavailable type %d\n", img->o_type);
  653.     }
  654.     break;
  655.  
  656. case FI_WHAT_FILE:
  657.     status = img->mid_type;
  658.     break;
  659.  
  660. #ifdef    COMMON_TOOL
  661. case FI_PNM_MAXVAL:
  662.     status = (int) xel24;
  663.     *((int*)fmt) = maxval;
  664.     break;
  665. #endif
  666.  
  667. case FI_DESC_ETA:
  668.     {
  669.     char    *tmp_buf;
  670.     CENR    *cer=(CENR *) vva_list;
  671.     register int    c_c[3];
  672.         for (i=0; i<img->channels; i++)
  673.         switch (cer[i].curve){
  674.         case ETALinear:
  675.             c_c[i] = cer[i].upper;    break;
  676.         case ETAForeGD:
  677.             c_c[i] = cer[i].fgrd;    break;
  678.         case ETABackGD:
  679.             c_c[i] = cer[i].bgrd;
  680.         default:mesg("\a");
  681.         }
  682.         sprintf(fmt, "%s [%d : %d]=R{%d}: -f%d; G{%d}: -f%d; B{%d}: -f%d\n",
  683.         Progname, img->fn, img->linearup, cer[0].curve, c_c[0],
  684.         cer[1].curve, c_c[1], cer[2].curve, c_c[2]);
  685.     /* not use realloc(), for saving original description */
  686.         i = img->desc ? strlen(img->desc) : 0;
  687.         tmp_buf = nzalloc(strlen(fmt)+i+1, 1);
  688.         if (img->desc)
  689.         strcpy(tmp_buf, img->desc),
  690.         free(img->desc);
  691.         else
  692.         tmp_buf[0] = 0;
  693.         strcat(tmp_buf, fmt);
  694.         img->desc = tmp_buf;
  695. #ifdef  HIPS_IMAGE
  696.         if (img->o_type == HIPS)
  697.         hhd.seq_desc = img->desc,
  698.         hhd.sizedesc = pointer_buffer_size(tmp_buf);
  699. #endif
  700.     }
  701.     break;
  702.  
  703. case FI_INIT_NAME:
  704.     img->name = str_save(Real_STR(fmt));
  705. #ifdef  HIPS_IMAGE
  706.     if (img->o_type==HIPS)    {
  707.         init_header(&hhd, img->name, "", img->frames, "",
  708.             img->height, img->width, img->o_form, 1, vva_list ?
  709.             (char*)vva_list : img->desc ? img->desc : "orig_init");
  710.         img->pxl_out = hhd.sizepix;
  711.     }
  712.     break;
  713.  
  714. case FI_HIPS_HEADER_FORMAT:
  715.     if (!hhd.orig_name || !hhd.seq_desc && !hhd.seq_history ||
  716.         !hhd.orows || !hhd.ocols || !hhd.num_frame)
  717.         status = (int)WHAT_Str;
  718.     else    status = (int)formatheader(&hhd);
  719. #endif
  720.     break;
  721.  
  722. default:message("need help ? %d\n", status=needs);
  723. }
  724. return    status;
  725. }
  726.